// ThreadSafeQueue.h
#pragma once

#include <queue>
#include <mutex>
#include <condition_variable>
#include <atomic>

template <typename T>
class ThreadSafeQueue
{
private:
    std::queue<T> m_queue;
    mutable std::mutex m_mutex;
    std::condition_variable m_cond;
    std::atomic<bool> m_stopped{false};

public:
    ThreadSafeQueue() = default;

    // 禁止拷贝（队列不支持拷贝）
    ThreadSafeQueue(const ThreadSafeQueue &) = delete;
    ThreadSafeQueue &operator=(const ThreadSafeQueue &) = delete;

    // 支持移动
    ThreadSafeQueue(ThreadSafeQueue &&other) noexcept
    {
        std::lock_guard<std::mutex> lk(other.m_mutex);
        m_queue = std::move(other.m_queue);
        m_stopped = other.m_stopped.load();
    }

    ~ThreadSafeQueue() = default;

    // 入队（支持左值和右值）
    void push(const T &item)
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        if (m_stopped)
            return; // 已停止，不再接受新元素
        m_queue.push(item);
        m_cond.notify_one(); // 通知一个等待的消费者
    }

    void push(T &&item)
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        if (m_stopped)
            return;
        m_queue.push(std::move(item));
        m_cond.notify_one();
    }

    // 出队（阻塞）
    // 返回值：true = 成功，false = 队列已停止
    bool pop(T &item)
    {
        std::unique_lock<std::mutex> lk(m_mutex);
        // 等待直到队列非空或已停止
        m_cond.wait(lk, [this]
                    { return !m_queue.empty() || m_stopped; });

        if (m_queue.empty())
        {
            return false; // 队列已停止
        }

        item = std::move(m_queue.front());
        m_queue.pop();
        return true;
    }

    // 出队（带超时）
    // 等待最多 `timeout_ms` 毫秒
    // 返回值：true = 成功，false = 超时或已停止
    bool pop(T &item, int timeout_ms)
    {
        std::unique_lock<std::mutex> lk(m_mutex);
        if (m_queue.empty())
        {
            auto timeout = std::chrono::milliseconds(timeout_ms);
            auto status = m_cond.wait_for(lk, timeout, [this]
                                          { return !m_queue.empty() || m_stopped; });
            if (!status)
            {
                return false; // 超时
            }
        }

        if (m_queue.empty())
        {
            return false; // 已停止
        }

        item = std::move(m_queue.front());
        m_queue.pop();
        return true;
    }

    // 立即出队（不等待）
    // 返回值：true = 成功，false = 队列空
    bool try_pop(T &item)
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        if (m_queue.empty())
        {
            return false;
        }
        item = std::move(m_queue.front());
        m_queue.pop();
        return true;
    }

    // 获取当前队列大小
    size_t size() const
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        return m_queue.size();
    }

    // 队列是否为空
    bool empty() const
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        return m_queue.empty();
    }

    // 停止队列（通知所有等待线程退出）
    void stop()
    {
        {
            std::lock_guard<std::mutex> lk(m_mutex);
            m_stopped = true;
        }
        m_cond.notify_all(); // 唤醒所有等待线程
    }

    // 重置队列（清空并恢复运行）
    void reset()
    {
        std::lock_guard<std::mutex> lk(m_mutex);
        while (!m_queue.empty())
        {
            m_queue.pop();
        }
        m_stopped = false;
    }
};